home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / net / pkt_cls.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  9.1 KB  |  366 lines
  1. #ifndef __NET_PKT_CLS_H
  2. #define __NET_PKT_CLS_H
  3.  
  4. #include <linux/pkt_cls.h>
  5. #include <net/sch_generic.h>
  6. #include <net/act_api.h>
  7.  
  8. /* Basic packet classifier frontend definitions. */
  9.  
  10. struct tcf_walker
  11. {
  12.     int    stop;
  13.     int    skip;
  14.     int    count;
  15.     int    (*fn)(struct tcf_proto *, unsigned long node, struct tcf_walker *);
  16. };
  17.  
  18. extern int register_tcf_proto_ops(struct tcf_proto_ops *ops);
  19. extern int unregister_tcf_proto_ops(struct tcf_proto_ops *ops);
  20.  
  21. static inline unsigned long
  22. __cls_set_class(unsigned long *clp, unsigned long cl)
  23. {
  24.     unsigned long old_cl;
  25.  
  26.     old_cl = *clp;
  27.     *clp = cl;
  28.     return old_cl;
  29. }
  30.  
  31. static inline unsigned long
  32. cls_set_class(struct tcf_proto *tp, unsigned long *clp, 
  33.     unsigned long cl)
  34. {
  35.     unsigned long old_cl;
  36.     
  37.     tcf_tree_lock(tp);
  38.     old_cl = __cls_set_class(clp, cl);
  39.     tcf_tree_unlock(tp);
  40.  
  41.     return old_cl;
  42. }
  43.  
  44. static inline void
  45. tcf_bind_filter(struct tcf_proto *tp, struct tcf_result *r, unsigned long base)
  46. {
  47.     unsigned long cl;
  48.  
  49.     cl = tp->q->ops->cl_ops->bind_tcf(tp->q, base, r->classid);
  50.     cl = cls_set_class(tp, &r->class, cl);
  51.     if (cl)
  52.         tp->q->ops->cl_ops->unbind_tcf(tp->q, cl);
  53. }
  54.  
  55. static inline void
  56. tcf_unbind_filter(struct tcf_proto *tp, struct tcf_result *r)
  57. {
  58.     unsigned long cl;
  59.  
  60.     if ((cl = __cls_set_class(&r->class, 0)) != 0)
  61.         tp->q->ops->cl_ops->unbind_tcf(tp->q, cl);
  62. }
  63.  
  64. struct tcf_exts
  65. {
  66. #ifdef CONFIG_NET_CLS_ACT
  67.     struct tc_action *action;
  68. #endif
  69. };
  70.  
  71. /* Map to export classifier specific extension TLV types to the
  72.  * generic extensions API. Unsupported extensions must be set to 0.
  73.  */
  74. struct tcf_ext_map
  75. {
  76.     int action;
  77.     int police;
  78. };
  79.  
  80. /**
  81.  * tcf_exts_is_predicative - check if a predicative extension is present
  82.  * @exts: tc filter extensions handle
  83.  *
  84.  * Returns 1 if a predicative extension is present, i.e. an extension which
  85.  * might cause further actions and thus overrule the regular tcf_result.
  86.  */
  87. static inline int
  88. tcf_exts_is_predicative(struct tcf_exts *exts)
  89. {
  90. #ifdef CONFIG_NET_CLS_ACT
  91.     return !!exts->action;
  92. #else
  93.     return 0;
  94. #endif
  95. }
  96.  
  97. /**
  98.  * tcf_exts_is_available - check if at least one extension is present
  99.  * @exts: tc filter extensions handle
  100.  *
  101.  * Returns 1 if at least one extension is present.
  102.  */
  103. static inline int
  104. tcf_exts_is_available(struct tcf_exts *exts)
  105. {
  106.     /* All non-predicative extensions must be added here. */
  107.     return tcf_exts_is_predicative(exts);
  108. }
  109.  
  110. /**
  111.  * tcf_exts_exec - execute tc filter extensions
  112.  * @skb: socket buffer
  113.  * @exts: tc filter extensions handle
  114.  * @res: desired result
  115.  *
  116.  * Executes all configured extensions. Returns 0 on a normal execution,
  117.  * a negative number if the filter must be considered unmatched or
  118.  * a positive action code (TC_ACT_*) which must be returned to the
  119.  * underlying layer.
  120.  */
  121. static inline int
  122. tcf_exts_exec(struct sk_buff *skb, struct tcf_exts *exts,
  123.            struct tcf_result *res)
  124. {
  125. #ifdef CONFIG_NET_CLS_ACT
  126.     if (exts->action)
  127.         return tcf_action_exec(skb, exts->action, res);
  128. #endif
  129.     return 0;
  130. }
  131.  
  132. extern int tcf_exts_validate(struct tcf_proto *tp, struct nlattr **tb,
  133.                          struct nlattr *rate_tlv, struct tcf_exts *exts,
  134.                          const struct tcf_ext_map *map);
  135. extern void tcf_exts_destroy(struct tcf_proto *tp, struct tcf_exts *exts);
  136. extern void tcf_exts_change(struct tcf_proto *tp, struct tcf_exts *dst,
  137.                          struct tcf_exts *src);
  138. extern int tcf_exts_dump(struct sk_buff *skb, struct tcf_exts *exts,
  139.                      const struct tcf_ext_map *map);
  140. extern int tcf_exts_dump_stats(struct sk_buff *skb, struct tcf_exts *exts,
  141.                            const struct tcf_ext_map *map);
  142.  
  143. /**
  144.  * struct tcf_pkt_info - packet information
  145.  */
  146. struct tcf_pkt_info
  147. {
  148.     unsigned char *        ptr;
  149.     int            nexthdr;
  150. };
  151.  
  152. #ifdef CONFIG_NET_EMATCH
  153.  
  154. struct tcf_ematch_ops;
  155.  
  156. /**
  157.  * struct tcf_ematch - extended match (ematch)
  158.  * 
  159.  * @matchid: identifier to allow userspace to reidentify a match
  160.  * @flags: flags specifying attributes and the relation to other matches
  161.  * @ops: the operations lookup table of the corresponding ematch module
  162.  * @datalen: length of the ematch specific configuration data
  163.  * @data: ematch specific data
  164.  */
  165. struct tcf_ematch
  166. {
  167.     struct tcf_ematch_ops * ops;
  168.     unsigned long        data;
  169.     unsigned int        datalen;
  170.     u16            matchid;
  171.     u16            flags;
  172. };
  173.  
  174. static inline int tcf_em_is_container(struct tcf_ematch *em)
  175. {
  176.     return !em->ops;
  177. }
  178.  
  179. static inline int tcf_em_is_simple(struct tcf_ematch *em)
  180. {
  181.     return em->flags & TCF_EM_SIMPLE;
  182. }
  183.  
  184. static inline int tcf_em_is_inverted(struct tcf_ematch *em)
  185. {
  186.     return em->flags & TCF_EM_INVERT;
  187. }
  188.  
  189. static inline int tcf_em_last_match(struct tcf_ematch *em)
  190. {
  191.     return (em->flags & TCF_EM_REL_MASK) == TCF_EM_REL_END;
  192. }
  193.  
  194. static inline int tcf_em_early_end(struct tcf_ematch *em, int result)
  195. {
  196.     if (tcf_em_last_match(em))
  197.         return 1;
  198.  
  199.     if (result == 0 && em->flags & TCF_EM_REL_AND)
  200.         return 1;
  201.  
  202.     if (result != 0 && em->flags & TCF_EM_REL_OR)
  203.         return 1;
  204.  
  205.     return 0;
  206. }
  207.     
  208. /**
  209.  * struct tcf_ematch_tree - ematch tree handle
  210.  *
  211.  * @hdr: ematch tree header supplied by userspace
  212.  * @matches: array of ematches
  213.  */
  214. struct tcf_ematch_tree
  215. {
  216.     struct tcf_ematch_tree_hdr hdr;
  217.     struct tcf_ematch *    matches;
  218.     
  219. };
  220.  
  221. /**
  222.  * struct tcf_ematch_ops - ematch module operations
  223.  * 
  224.  * @kind: identifier (kind) of this ematch module
  225.  * @datalen: length of expected configuration data (optional)
  226.  * @change: called during validation (optional)
  227.  * @match: called during ematch tree evaluation, must return 1/0
  228.  * @destroy: called during destroyage (optional)
  229.  * @dump: called during dumping process (optional)
  230.  * @owner: owner, must be set to THIS_MODULE
  231.  * @link: link to previous/next ematch module (internal use)
  232.  */
  233. struct tcf_ematch_ops
  234. {
  235.     int            kind;
  236.     int            datalen;
  237.     int            (*change)(struct tcf_proto *, void *,
  238.                       int, struct tcf_ematch *);
  239.     int            (*match)(struct sk_buff *, struct tcf_ematch *,
  240.                      struct tcf_pkt_info *);
  241.     void            (*destroy)(struct tcf_proto *,
  242.                        struct tcf_ematch *);
  243.     int            (*dump)(struct sk_buff *, struct tcf_ematch *);
  244.     struct module        *owner;
  245.     struct list_head    link;
  246. };
  247.  
  248. extern int tcf_em_register(struct tcf_ematch_ops *);
  249. extern int tcf_em_unregister(struct tcf_ematch_ops *);
  250. extern int tcf_em_tree_validate(struct tcf_proto *, struct nlattr *,
  251.                 struct tcf_ematch_tree *);
  252. extern void tcf_em_tree_destroy(struct tcf_proto *, struct tcf_ematch_tree *);
  253. extern int tcf_em_tree_dump(struct sk_buff *, struct tcf_ematch_tree *, int);
  254. extern int __tcf_em_tree_match(struct sk_buff *, struct tcf_ematch_tree *,
  255.                    struct tcf_pkt_info *);
  256.  
  257. /**
  258.  * tcf_em_tree_change - replace ematch tree of a running classifier
  259.  *
  260.  * @tp: classifier kind handle
  261.  * @dst: destination ematch tree variable
  262.  * @src: source ematch tree (temporary tree from tcf_em_tree_validate)
  263.  *
  264.  * This functions replaces the ematch tree in @dst with the ematch
  265.  * tree in @src. The classifier in charge of the ematch tree may be
  266.  * running.
  267.  */
  268. static inline void tcf_em_tree_change(struct tcf_proto *tp,
  269.                       struct tcf_ematch_tree *dst,
  270.                       struct tcf_ematch_tree *src)
  271. {
  272.     tcf_tree_lock(tp);
  273.     memcpy(dst, src, sizeof(*dst));
  274.     tcf_tree_unlock(tp);
  275. }
  276.  
  277. /**
  278.  * tcf_em_tree_match - evaulate an ematch tree
  279.  *
  280.  * @skb: socket buffer of the packet in question
  281.  * @tree: ematch tree to be used for evaluation
  282.  * @info: packet information examined by classifier
  283.  *
  284.  * This function matches @skb against the ematch tree in @tree by going
  285.  * through all ematches respecting their logic relations returning
  286.  * as soon as the result is obvious.
  287.  *
  288.  * Returns 1 if the ematch tree as-one matches, no ematches are configured
  289.  * or ematch is not enabled in the kernel, otherwise 0 is returned.
  290.  */
  291. static inline int tcf_em_tree_match(struct sk_buff *skb,
  292.                     struct tcf_ematch_tree *tree,
  293.                     struct tcf_pkt_info *info)
  294. {
  295.     if (tree->hdr.nmatches)
  296.         return __tcf_em_tree_match(skb, tree, info);
  297.     else
  298.         return 1;
  299. }
  300.  
  301. #define MODULE_ALIAS_TCF_EMATCH(kind)    MODULE_ALIAS("ematch-kind-" __stringify(kind))
  302.  
  303. #else /* CONFIG_NET_EMATCH */
  304.  
  305. struct tcf_ematch_tree
  306. {
  307. };
  308.  
  309. #define tcf_em_tree_validate(tp, tb, t) ((void)(t), 0)
  310. #define tcf_em_tree_destroy(tp, t) do { (void)(t); } while(0)
  311. #define tcf_em_tree_dump(skb, t, tlv) (0)
  312. #define tcf_em_tree_change(tp, dst, src) do { } while(0)
  313. #define tcf_em_tree_match(skb, t, info) ((void)(info), 1)
  314.  
  315. #endif /* CONFIG_NET_EMATCH */
  316.  
  317. static inline unsigned char * tcf_get_base_ptr(struct sk_buff *skb, int layer)
  318. {
  319.     switch (layer) {
  320.         case TCF_LAYER_LINK:
  321.             return skb->data;
  322.         case TCF_LAYER_NETWORK:
  323.             return skb_network_header(skb);
  324.         case TCF_LAYER_TRANSPORT:
  325.             return skb_transport_header(skb);
  326.     }
  327.  
  328.     return NULL;
  329. }
  330.  
  331. static inline int tcf_valid_offset(const struct sk_buff *skb,
  332.                    const unsigned char *ptr, const int len)
  333. {
  334.     return unlikely((ptr + len) < skb_tail_pointer(skb) && ptr > skb->head);
  335. }
  336.  
  337. #ifdef CONFIG_NET_CLS_IND
  338. #include <net/net_namespace.h>
  339.  
  340. static inline int
  341. tcf_change_indev(struct tcf_proto *tp, char *indev, struct nlattr *indev_tlv)
  342. {
  343.     if (nla_strlcpy(indev, indev_tlv, IFNAMSIZ) >= IFNAMSIZ)
  344.         return -EINVAL;
  345.     return 0;
  346. }
  347.  
  348. static inline int
  349. tcf_match_indev(struct sk_buff *skb, char *indev)
  350. {
  351.     struct net_device *dev;
  352.  
  353.     if (indev[0]) {
  354.         if  (!skb->iif)
  355.             return 0;
  356.         dev = __dev_get_by_index(dev_net(skb->dev), skb->iif);
  357.         if (!dev || strcmp(indev, dev->name))
  358.             return 0;
  359.     }
  360.  
  361.     return 1;
  362. }
  363. #endif /* CONFIG_NET_CLS_IND */
  364.  
  365. #endif
  366.